package mvc_generator.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import mvc_generator.mVCGenerator.ArithmeticExpression;
import mvc_generator.mVCGenerator.ArithmeticVariable;
import mvc_generator.mVCGenerator.AssignedField;
import mvc_generator.mVCGenerator.Bloc;
import mvc_generator.mVCGenerator.BooleanExpression;
import mvc_generator.mVCGenerator.BooleanPrimitive;
import mvc_generator.mVCGenerator.BooleanType;
import mvc_generator.mVCGenerator.BooleanVariable;
import mvc_generator.mVCGenerator.Condition;
import mvc_generator.mVCGenerator.Config;
import mvc_generator.mVCGenerator.Controller;
import mvc_generator.mVCGenerator.Data;
import mvc_generator.mVCGenerator.DateExpression;
import mvc_generator.mVCGenerator.DateType;
import mvc_generator.mVCGenerator.Declaration;
import mvc_generator.mVCGenerator.DoubleExpression;
import mvc_generator.mVCGenerator.DoubleType;
import mvc_generator.mVCGenerator.Form;
import mvc_generator.mVCGenerator.FormValidation;
import mvc_generator.mVCGenerator.IntegerExpression;
import mvc_generator.mVCGenerator.IntegerType;
import mvc_generator.mVCGenerator.MVCGeneratorPackage;
import mvc_generator.mVCGenerator.Model;
import mvc_generator.mVCGenerator.ModelMVC;
import mvc_generator.mVCGenerator.ParenthesizedArithmeticExpression;
import mvc_generator.mVCGenerator.ParenthesizedBooleanExpression;
import mvc_generator.mVCGenerator.StringExpression;
import mvc_generator.mVCGenerator.StringLengthExpression;
import mvc_generator.mVCGenerator.StringType;
import mvc_generator.mVCGenerator.View;
import mvc_generator.services.MVCGeneratorGrammarAccess;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class MVCGeneratorSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private MVCGeneratorGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == MVCGeneratorPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case MVCGeneratorPackage.ARITHMETIC_EXPRESSION:
				if(context == grammarAccess.getArithmeticExpressionRule() ||
				   context == grammarAccess.getExpressionRule()) {
					sequence_ArithmeticExpression(context, (ArithmeticExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.ARITHMETIC_VARIABLE:
				if(context == grammarAccess.getArithmeticVariableRule()) {
					sequence_ArithmeticVariable(context, (ArithmeticVariable) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.ASSIGNED_FIELD:
				if(context == grammarAccess.getAssignedFieldRule()) {
					sequence_AssignedField(context, (AssignedField) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.BLOC:
				if(context == grammarAccess.getBlocRule()) {
					sequence_Bloc(context, (Bloc) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.BOOLEAN_EXPRESSION:
				if(context == grammarAccess.getBooleanExpressionRule() ||
				   context == grammarAccess.getExpressionRule()) {
					sequence_BooleanExpression(context, (BooleanExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.BOOLEAN_PRIMITIVE:
				if(context == grammarAccess.getBooleanPrimitiveRule()) {
					sequence_BooleanPrimitive(context, (BooleanPrimitive) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.BOOLEAN_TYPE:
				if(context == grammarAccess.getBooleanTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule()) {
					sequence_BooleanType(context, (BooleanType) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.BOOLEAN_VARIABLE:
				if(context == grammarAccess.getBooleanVariableRule()) {
					sequence_BooleanVariable(context, (BooleanVariable) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.CONDITION:
				if(context == grammarAccess.getConditionRule()) {
					sequence_Condition(context, (Condition) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.CONFIG:
				if(context == grammarAccess.getConfigRule()) {
					sequence_Config(context, (Config) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.CONTROLLER:
				if(context == grammarAccess.getControllerRule()) {
					sequence_Controller(context, (Controller) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.DATA:
				if(context == grammarAccess.getDataRule()) {
					sequence_Data(context, (Data) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.DATE_EXPRESSION:
				if(context == grammarAccess.getDateExpressionRule() ||
				   context == grammarAccess.getExpressionRule()) {
					sequence_DateExpression(context, (DateExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.DATE_TYPE:
				if(context == grammarAccess.getDateTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule()) {
					sequence_DateType(context, (DateType) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.DECLARATION:
				if(context == grammarAccess.getDeclarationRule()) {
					sequence_Declaration(context, (Declaration) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.DOUBLE_EXPRESSION:
				if(context == grammarAccess.getArithmeticPrimitiveRule() ||
				   context == grammarAccess.getDoubleExpressionRule()) {
					sequence_DoubleExpression(context, (DoubleExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.DOUBLE_TYPE:
				if(context == grammarAccess.getDoubleTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule()) {
					sequence_DoubleType(context, (DoubleType) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.FORM:
				if(context == grammarAccess.getFormRule()) {
					sequence_Form(context, (Form) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.FORM_VALIDATION:
				if(context == grammarAccess.getFormValidationRule()) {
					sequence_FormValidation(context, (FormValidation) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.INTEGER_EXPRESSION:
				if(context == grammarAccess.getArithmeticPrimitiveRule() ||
				   context == grammarAccess.getIntegerExpressionRule()) {
					sequence_IntegerExpression(context, (IntegerExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.INTEGER_TYPE:
				if(context == grammarAccess.getIntegerTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule()) {
					sequence_IntegerType(context, (IntegerType) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.MODEL:
				if(context == grammarAccess.getModelRule()) {
					sequence_Model(context, (Model) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.MODEL_MVC:
				if(context == grammarAccess.getModelMVCRule()) {
					sequence_ModelMVC(context, (ModelMVC) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.PARENTHESIZED_ARITHMETIC_EXPRESSION:
				if(context == grammarAccess.getParenthesizedArithmeticExpressionRule()) {
					sequence_ParenthesizedArithmeticExpression(context, (ParenthesizedArithmeticExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.PARENTHESIZED_BOOLEAN_EXPRESSION:
				if(context == grammarAccess.getParenthesizedBooleanExpressionRule()) {
					sequence_ParenthesizedBooleanExpression(context, (ParenthesizedBooleanExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.STRING_EXPRESSION:
				if(context == grammarAccess.getArithmeticPrimitiveRule() ||
				   context == grammarAccess.getStringExpressionRule()) {
					sequence_StringExpression(context, (StringExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.STRING_LENGTH_EXPRESSION:
				if(context == grammarAccess.getStringLengthExpressionRule()) {
					sequence_StringLengthExpression(context, (StringLengthExpression) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.STRING_TYPE:
				if(context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getStringTypeRule()) {
					sequence_StringType(context, (StringType) semanticObject); 
					return; 
				}
				else break;
			case MVCGeneratorPackage.VIEW:
				if(context == grammarAccess.getViewRule()) {
					sequence_View(context, (View) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (
	 *         (op1=ArithmeticVariable | op1=StringLengthExpression | op1=ArithmeticPrimitive) 
	 *         (
	 *             (
	 *                 symbol='+' | 
	 *                 symbol='-' | 
	 *                 symbol='*' | 
	 *                 symbol='/' | 
	 *                 symbol='>' | 
	 *                 symbol='>=' | 
	 *                 symbol='<' | 
	 *                 symbol='<=' | 
	 *                 symbol='=='
	 *             ) 
	 *             (op2=ArithmeticVariable | op2=StringLengthExpression | op2=ArithmeticPrimitive | op2=ParenthesizedArithmeticExpression)
	 *         )?
	 *     )
	 */
	protected void sequence_ArithmeticExpression(EObject context, ArithmeticExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     refer=ID
	 */
	protected void sequence_ArithmeticVariable(EObject context, ArithmeticVariable semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.ARITHMETIC_VARIABLE__REFER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.ARITHMETIC_VARIABLE__REFER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getArithmeticVariableAccess().getReferIDTerminalRuleCall_0(), semanticObject.getRefer());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     fieldName=ID
	 */
	protected void sequence_AssignedField(EObject context, AssignedField semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.ASSIGNED_FIELD__FIELD_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.ASSIGNED_FIELD__FIELD_NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAssignedFieldAccess().getFieldNameIDTerminalRuleCall_0(), semanticObject.getFieldName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (blocDescription=STRING? conditions+=Condition* viewOnSuccess=[View|ID]? errorDescription=STRING?)
	 */
	protected void sequence_Bloc(EObject context, Bloc semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         (op1=BooleanVariable | op1=BooleanPrimitive) 
	 *         ((symbol='||' | symbol='&&' | symbol='==') (op2=BooleanVariable | op2=BooleanPrimitive | op2=ParenthesizedBooleanExpression))?
	 *     )
	 */
	protected void sequence_BooleanExpression(EObject context, BooleanExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (value='true' | value='false')
	 */
	protected void sequence_BooleanPrimitive(EObject context, BooleanPrimitive semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     stringRepresentation='boolean'
	 */
	protected void sequence_BooleanType(EObject context, BooleanType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBooleanTypeAccess().getStringRepresentationBooleanKeyword_0(), semanticObject.getStringRepresentation());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     refer=ID
	 */
	protected void sequence_BooleanVariable(EObject context, BooleanVariable semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.BOOLEAN_VARIABLE__REFER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.BOOLEAN_VARIABLE__REFER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBooleanVariableAccess().getReferIDTerminalRuleCall_2_0(), semanticObject.getRefer());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (condValue=BooleanExpression | condValue=ArithmeticExpression)
	 */
	protected void sequence_Condition(EObject context, Condition semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (indexView=[View|ID] frameworks+=ID*)
	 */
	protected void sequence_Config(EObject context, Config semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID controlledView=[View|ID] declarations+=Declaration* formValidations+=FormValidation*)
	 */
	protected void sequence_Controller(EObject context, Controller semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID declarations+=Declaration*)
	 */
	protected void sequence_Data(EObject context, Data semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (day=INT month=INT year=INT)
	 */
	protected void sequence_DateExpression(EObject context, DateExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DATE_EXPRESSION__DAY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DATE_EXPRESSION__DAY));
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DATE_EXPRESSION__MONTH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DATE_EXPRESSION__MONTH));
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DATE_EXPRESSION__YEAR) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DATE_EXPRESSION__YEAR));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDateExpressionAccess().getDayINTTerminalRuleCall_2_0(), semanticObject.getDay());
		feeder.accept(grammarAccess.getDateExpressionAccess().getMonthINTTerminalRuleCall_4_0(), semanticObject.getMonth());
		feeder.accept(grammarAccess.getDateExpressionAccess().getYearINTTerminalRuleCall_6_0(), semanticObject.getYear());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     stringRepresentation='date'
	 */
	protected void sequence_DateType(EObject context, DateType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDateTypeAccess().getStringRepresentationDateKeyword_0(), semanticObject.getStringRepresentation());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (type=SimpleType name=ID)
	 */
	protected void sequence_Declaration(EObject context, Declaration semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DECLARATION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DECLARATION__TYPE));
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DECLARATION__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDeclarationAccess().getTypeSimpleTypeParserRuleCall_0_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (value=INT decimalValue=INT)
	 */
	protected void sequence_DoubleExpression(EObject context, DoubleExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DOUBLE_EXPRESSION__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DOUBLE_EXPRESSION__VALUE));
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.DOUBLE_EXPRESSION__DECIMAL_VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.DOUBLE_EXPRESSION__DECIMAL_VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDoubleExpressionAccess().getValueINTTerminalRuleCall_0_0(), semanticObject.getValue());
		feeder.accept(grammarAccess.getDoubleExpressionAccess().getDecimalValueINTTerminalRuleCall_2_0(), semanticObject.getDecimalValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     stringRepresentation='double'
	 */
	protected void sequence_DoubleType(EObject context, DoubleType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDoubleTypeAccess().getStringRepresentationDoubleKeyword_0(), semanticObject.getStringRepresentation());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (validatedFormName=ID blocs+=Bloc+)
	 */
	protected void sequence_FormValidation(EObject context, FormValidation semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID assignedFields+=AssignedField*)
	 */
	protected void sequence_Form(EObject context, Form semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value=INT
	 */
	protected void sequence_IntegerExpression(EObject context, IntegerExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.INTEGER_EXPRESSION__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.INTEGER_EXPRESSION__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getIntegerExpressionAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     stringRepresentation='int'
	 */
	protected void sequence_IntegerType(EObject context, IntegerType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getIntegerTypeAccess().getStringRepresentationIntKeyword_0(), semanticObject.getStringRepresentation());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID config=Config model=Model views+=View* controllers+=Controller*)
	 */
	protected void sequence_ModelMVC(EObject context, ModelMVC semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     datas+=Data*
	 */
	protected void sequence_Model(EObject context, Model semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     expression=ArithmeticExpression
	 */
	protected void sequence_ParenthesizedArithmeticExpression(EObject context, ParenthesizedArithmeticExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.PARENTHESIZED_ARITHMETIC_EXPRESSION__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.PARENTHESIZED_ARITHMETIC_EXPRESSION__EXPRESSION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getParenthesizedArithmeticExpressionAccess().getExpressionArithmeticExpressionParserRuleCall_1_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     expression=BooleanExpression
	 */
	protected void sequence_ParenthesizedBooleanExpression(EObject context, ParenthesizedBooleanExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.PARENTHESIZED_BOOLEAN_EXPRESSION__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.PARENTHESIZED_BOOLEAN_EXPRESSION__EXPRESSION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getParenthesizedBooleanExpressionAccess().getExpressionBooleanExpressionParserRuleCall_1_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     value=STRING
	 */
	protected void sequence_StringExpression(EObject context, StringExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.STRING_EXPRESSION__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.STRING_EXPRESSION__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getStringExpressionAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (expression=StringExpression | expression=ArithmeticVariable)
	 */
	protected void sequence_StringLengthExpression(EObject context, StringLengthExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     stringRepresentation='string'
	 */
	protected void sequence_StringType(EObject context, StringType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MVCGeneratorPackage.Literals.SIMPLE_TYPE__STRING_REPRESENTATION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getStringTypeAccess().getStringRepresentationStringKeyword_0(), semanticObject.getStringRepresentation());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID forms+=Form*)
	 */
	protected void sequence_View(EObject context, View semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
